// 221102 yan 封装自定义模块数字字段计算功能

// let {evaluate,Function} = require('../../eval5/eval5.min.js');

module.exports = Behavior({
  data:{
    computeField: {}
  },
  methods: {
    initExpData(){
      let {expList,computeField} = this.data;
      wx.$each(expList,(i,item)=>{
        let exp = item.computeExpress,
          fieldid = item.field_id || item.fieldName,
          reg_g = /\{(.+?)\}/g;   //把字符串分割成含有大括号的数组
        let comf = exp.match(reg_g);
        if (exp.substring(0,1) === '=') { //函数公式包含非数字字段
          exp = exp.substring(1);
          let regx = /[<>=（）‘’“”，]/g;
          if (regx.test(exp)) {
            exp = exp.replace(/(=)+/g, '==')
              .replace(/(<)+/g, '<')
              .replace(/(>)+/g, '>')
              .replace(/(<==)/g, '<=')
              .replace(/(>==)/g, '>=')
              .replace(/(）)/g,')')
              .replace(/(（)/g,'(')
              .replace(/(，)/g,',')
              .replace(/‘|’|“|”/g,'"');
          }
        }
        wx.$each(comf,(i,item)=>{
          let comv = item.match(/{(\S*)}/)[1];  //匹配大括号内的值
          if (computeField[comv]) {
            computeField[comv].push({exp,fieldid});
          }else {
            computeField[comv] = [{exp,fieldid}];
          }
        });
      });
    },

    calculate(field,val){
      let {defData,entity,inputData,computeField} = this.data,
        row = [];
      if (!computeField[field])return;
      wx.$each(defData,(key,val)=>{
        if (key.indexOf(';')>=0 || ['table_id','parent_table_id'].includes(key))return;
        row.push({
          field_id: key,
          field_value: val
        })
      });
      let url = 'Custom/mark_entity_field_cal',
        post = {
          table_id: entity,
          field_id: field,
          is_all: true,
          row
        };
      wx.$post(1,url,post).then(res=>{
        if (res.errcode != 0)return;
        let data = res.data.row || [];
        wx.$each(data,(i,item)=>{
          let rs = item.field_value || 0;
          inputData[item.field_id] = rs;
          defData[item.field_id] = rs;
        });

        this.setData({isEdit: true});
        this.setData({defData});
        this.setData({isEdit: false});
      })
    },
    //221230 yan 修改计算公式--取消使用
    calculate2(field,val){
      this._calculate(field);
      let {defData} = this.data;
      this.setData({isEdit: true});
      this.setData({defData});
      this.setData({isEdit: false});
    },

    _calculate(field){
      let {computeField,defData} = this.data;
      if (computeField[field]) {
        wx.$each(computeField[field],(i,item)=>{
          this.processCal(item,field)
        });
      }

    },
    processCal(data,id){
        let inputData = this.data.inputData.entity,
          defData = this.data.defData,
          exp = data.exp,
          destField = data.fieldid;

        let reg_g = /\{(.+?)\}/g;   //把字符串分割成含有大括号的数组
        let comf = exp.match(reg_g);
        wx.$each(comf,(i,item)=>{
          let comv = item.match(/{(\S*)}/)[1];  //匹配大括号内的值

          let val = (isNaN(inputData[comv]) ? inputData[comv] : parseFloat(inputData[comv]) ) || 0;
          exp = exp.replace(item,'(' + val+')')
        });

      let funObj = {iif,equal,choice,add,sub,multiplication,division,division1,division2,getDate,getMonth,getFullYear,getYear,comparisonDateByDay,dateAddDay,dateAddMonth,dateAddYear,Date,parseInt,parseFloat,isNaN};

      let result = evaluate(exp,funObj);
          if (Object.is(NaN, result)) result = 0;
          inputData[destField] = result;
          defData[destField] = result;
      this._calculate(destField);
    },
    //END

  }
});

/**
 * 逻辑判断
 * @param condition 判断条件
 * @param value1 判断ture返回值
 * @param value2 判断false返回值
 * @return {*}
 */
let iif = function(condition,value1,value2) {
  if (condition){
    return value1;
  }
  return value2;
};

/**
 * 比较函数
 * @param value1  比较值1
 * @param value2 比较值2
 * @return {boolean} 返回比较值1是否等于比较值2
 */
function equal(value1,value2) {
  return value1 == value2;
}

/**
 * 多条件判断
 * 可传入多个参数 （条件1，结果1，条件2，结果2，...,缺省值）
 * @return {any}
 */
function choice() {
  let arr = arguments; //获取传参集合
  if (arr.length > 0){
    let g = parseInt(arr.length/2),
      y = arr.length%2; //求余
    let res = '';
    for (let i = 0;i <(arr.length-y); i=i+2){
      // let condi = bool(arr[i]);
      if (arr[i]){
        return arr[i+1];
      }
    }
    if (y === 1){
      return arr[arr.length-1]
    }
  }
}
function bool(str){
  //有equal的
  if (str.indexOf('equal(')>=0) {
    return new Function(str)();
  }
  //有比较符的
  let regx = /[<>=]/g;
  if (regx.test(str)){
    let f = str.replace(/(=)\1+/g,'==').replace(/(<)\1+/g,'<').replace(/(>)\1+/g,'>').replace(/(<==)/g,'<=').replace(/(>==)/g,'>=');
    return f
  }
  //单个字符串的
  if (!isNaN(str)){  //数字
    str = Number(str);
  }
  return Boolean(str);
}

/**
 * 加法
 * @param {参数1} value1
 * @param {参数2} value2
 * @returns 返回相加后(value1+value2)的结果 保留四位小数
 */
function add(value1,value2)
{
  if (isNaN(value1) || isNaN(value2)){
    layer.msg("参数错误");
  }
  value1 = parseFloat(value1).toFixed(4);
  value2 = parseFloat(value2).toFixed(4);
  return (value1+value2).toFixed(4);
}
/**
 * 减法
 * @param {参数1} value1
 * @param {参数2} value2
 * @returns 返回相减后(value1-value2)的结果 保留四位小数
 */
function sub(value1,value2)
{
  if (isNaN(value1) || isNaN(value2)){
    layer.msg("参数错误");
  }
  value1 = parseFloat(value1).toFixed(4);
  value2 = parseFloat(value2).toFixed(4);

  return (value1-value2).toFixed(4);
}
/**
 * 乘法
 * @param {参数1} value1
 * @param {参数2} value2
 * @returns 返回相乘后(value1*value2)的结果 保留四位小数
 */
function multiplication(value1,value2)
{
  if (isNaN(value1) || isNaN(value2)){
    layer.msg("参数错误");
  }
  value1 = parseFloat(value1).toFixed(4);
  value2 = parseFloat(value2).toFixed(4);

  return (value1*value2).toFixed(4);
}
/**
 * 除法
 * @param {参数1} value1
 * @param {参数2} value2
 * @returns 返回相除后(value1÷value2)的结果 保留四位小数
 */
function division(value1,value2)
{
  if (isNaN(value1) || isNaN(value2)){
    layer.msg("参数错误");
  }
  value1 = parseFloat(value1).toFixed(4);
  value2 = parseFloat(value2).toFixed(4);

  return (value1/value2).toFixed(4);
}
/**
 * 除法1
 * @param {参数1} value1
 * @param {参数2} value2
 * @returns 返回相除后(value1÷value2)的结果 取整 不四舍五入
 */
function division1(value1,value2)
{
  if (isNaN(value1) || isNaN(value2)){
    layer.msg("参数错误");
  }
  value1 = parseFloat(value1).toFixed(4);
  value2 = parseFloat(value2).toFixed(4);

  return parseInt(value1/value2);
}
/**
 * 除法2
 * @param {参数1} value1
 * @param {参数2} value2
 * @returns 返回相除后(value1÷value2)的结果 取整 四舍五入
 */
function division2(value1,value2)
{
  if (isNaN(value1) || isNaN(value2)){
    layer.msg("参数错误");
  }
  value1 = parseFloat(value1).toFixed(4);
  value2 = parseFloat(value2).toFixed(4);

  return Math.round(value1/value2);
}
/**
 * 日期函数 返回当前日期几号
 * @param {日期} date
 * @returns 返回几号 (1 ~ 31)。
 */
function getDate(date)
{
  var mydate = new Date(date);
  return mydate.getDate();
}
/**
 * 日期函数 返回当前日期月份
 * @param {日期} date
 * @returns 返回月份 (1 ~ 12)，从1开始
 */
function getMonth(date)
{
  var mydate = new Date(date);
  return mydate.getMonth()+1;
}
/**
 * 日期函数 返回当前日期年份
 * @param {日期} date
 * @returns 返回四位数字的年份
 */
function getFullYear(date)
{
  var mydate=new Date(date)
  return mydate.getFullYear();
}
/**
 * 日期函数 返回当前日期年份
 * @param {日期} date
 * @returns 两位数的年份，从1900年开始
 */
function getYear(date)
{
  var mydate=new Date(date);
  return mydate.getYear();
}
/**
 * 日期函数 返回相差天数
 * @param {开始时间} startDate
 * @param {结束时间} endDate
 * @returns 返回相差天数
 */
function comparisonDateByDay(startDate,endDate)
{
  var myStartTime=new Date(startDate);
  var myEndTime=new Date(endDate);
  var myDay=parseInt((myStartTime.getTime()-myEndTime.getTime())/1000/60/60/24)
  return myDay;
}
/**
 * 日期函数 增加天数
 * @param {当前日期} date
 * @param {增加天数} day
 * @returns 新日期= 当前日期+增加天数
 */
function dateAddDay(date,day)
{
  var myDate=new Date(date);
  myDate.setDate(myDate.getDate()+parseInt(day));
  return myDate;
}
/**
 * 日期函数 增加月份
 * @param {当前日期} date
 * @param {增加月份} month
 * @returns 新日期= 当前日期+增加月份
 */
function dateAddMonth(date,month)
{
  var myDate=new Date(date);
  myDate.setMonth(myDate.getMonth()+parseInt(month))
  return myDate;
}
function dateAddYear(date,year)
{
  var myDate=new Date(date);
  myDate.setFullYear
}

